home *** CD-ROM | disk | FTP | other *** search
/ Aminet 12 / Aminet 12 (1996)(GTI - Schatztruhe)[!][Jun 1996].iso / Aminet / dev / c / PhoneLogDevKit.lha / PhoneLog / src / PhoneLogParser.c < prev    next >
Encoding:
C/C++ Source or Header  |  1996-03-16  |  37.7 KB  |  1,747 lines
  1. /* $Id: Parser.c,v 2.9 1992/08/07 15:28:42 grosch rel $ */
  2.  
  3. #define bool  char
  4. #define true  1
  5. #define false 0
  6.  
  7. #include "PhoneLogParser.h"
  8. #include "Errors.h"
  9. #include "Memory.h"
  10. #include "DynArray.h"
  11. #include "Sets.h"
  12. #include <string.h>
  13. #ifndef BCOPY
  14.   #include <memory.h>
  15. #endif
  16.  
  17.  
  18. #ifdef lex_interface
  19.  #define PhoneLogScanner_GetToken yylex
  20.   extern int yylex(void);
  21.   #ifndef AttributeDef
  22.     #include "Positions.h"
  23.    typedef struct {tPosition Position;} PhoneLogScanner_tScanAttribute;
  24.    static PhoneLogScanner_tScanAttribute PhoneLogScanner_Attribute = {{0,0}};
  25.   #endif
  26.   #ifndef ErrorAttributeDef
  27.    #define PhoneLogScanner_ErrorAttribute(Token,RepairAttribute)
  28.   #endif
  29.   #ifndef yyGetAttribute
  30.     #define yyGetAttribute(yyAttrStackPtr,Attribute) *yyAttrStackPtr = yylval
  31.   #endif
  32. #else
  33.  #include "PhoneLogScanner.h"
  34.   #ifndef yyGetAttribute
  35.     #define yyGetAttribute(yyAttrStackPtr,Attribute) (yyAttrStackPtr)->Scan = Attribute
  36.   #endif
  37. #endif
  38.  
  39.  
  40. /* line 10 "t:lalr.tmp" */
  41. /* line 10 "PhoneLogParser.lalr" */
  42. /*GLOBAL*/
  43.         #include <stdio.h>
  44.         #include <stdlib.h>
  45.         #include <string.h>
  46.         #include "PhoneLog.h"
  47.         #include "PhoneLogParserInterface.h"
  48.  
  49.         typedef struct {
  50.                         PhoneLogScanner_tScanAttribute Scan;
  51.                        } tParsAttribute;
  52.  
  53.  
  54.         struct PhoneLogMarker Marker;
  55.         struct PhoneLogEntry  Entry;
  56.  
  57.         static unsigned short Day,Month,Hour,Min,Sec;
  58.         static int Year;
  59.         /*GLOBAL*/
  60.  
  61.  
  62. #if defined lex_interface & ! defined yylvalDef
  63.   tParsAttribute yylval;
  64. #endif
  65. #ifndef yyInitStackSize
  66.   #define yyInitStackSize 100
  67. #endif
  68. #define yyNoState 0
  69.  
  70.  
  71. # define yyFirstTerminal    0
  72. # define yyLastTerminal        81
  73. # define yyTableMax        168
  74. # define yyNTableMax        130
  75. # define yyFirstReadState    1
  76. # define yyLastReadState    72
  77. # define yyFirstReadTermState    73
  78. # define yyLastReadTermState    90
  79. # define yyLastReadNontermState    105
  80. # define yyFirstReduceState    106
  81. # define yyLastReduceState    162
  82. # define yyStartState        1
  83. # define yyStopState        106
  84.  
  85.  
  86. #define yyFirstFinalState yyFirstReadTermState
  87.  
  88.  
  89. typedef unsigned short yyStateRange;
  90. typedef unsigned short yySymbolRange;
  91. typedef struct {yyStateRange Check, Next;} yyTCombType;
  92.  
  93.  
  94. char *PhoneLogParser_TokenName[yyLastTerminal+1] = {
  95. "_EndOfFile",
  96. "digits",
  97. "text",
  98. 0,
  99. 0,
  100. 0,
  101. 0,
  102. 0,
  103. 0,
  104. 0,
  105. "=",
  106. ">",
  107. 0,
  108. 0,
  109. 0,
  110. 0,
  111. 0,
  112. 0,
  113. 0,
  114. 0,
  115. "<PHONELOG",
  116. "</PHONELOG>",
  117. "<ENTRY>",
  118. "</ENTRY>",
  119. "<HOST>",
  120. "</HOST>",
  121. "<NUMBER>",
  122. "</NUMBER>",
  123. "<HOSTNAME>",
  124. "</HOSTNAME>",
  125. "<START>",
  126. "</START>",
  127. "<END>",
  128. "</END>",
  129. "<DATE>",
  130. "</DATE>",
  131. "<TIME>",
  132. "</TIME>",
  133. "<PERIOD>",
  134. "</PERIOD>",
  135. "<MARK>",
  136. "</MARK>",
  137. "<PROGRAM",
  138. "</PROGRAM>",
  139. "<MARKNAME>",
  140. "</MARKNAME>",
  141. "<REASON>",
  142. "</REASON>",
  143. 0,
  144. 0,
  145. 0,
  146. 0,
  147. 0,
  148. 0,
  149. 0,
  150. 0,
  151. 0,
  152. 0,
  153. 0,
  154. 0,
  155. 0,
  156. 0,
  157. 0,
  158. 0,
  159. 0,
  160. 0,
  161. 0,
  162. 0,
  163. 0,
  164. 0,
  165. 0,
  166. 0,
  167. 0,
  168. 0,
  169. 0,
  170. 0,
  171. 0,
  172. 0,
  173. 0,
  174. 0,
  175. "version",
  176. "revision",
  177. };
  178. static yyTCombType yyTComb[yyTableMax+1] = {
  179. {10, 110},
  180. {4, 5},
  181. {8, 73},
  182. {11, 108},
  183. {16, 17},
  184. {20, 75},
  185. {22, 23},
  186. {26, 27},
  187. {29, 30},
  188. {32, 33},
  189. {3, 4},
  190. {2, 114},
  191. {5, 119},
  192. {6, 117},
  193. {7, 8},
  194. {9, 10},
  195. {14, 147},
  196. {15, 16},
  197. {17, 152},
  198. {18, 150},
  199. {1, 2},
  200. {10, 110},
  201. {10, 110},
  202. {19, 20},
  203. {11, 74},
  204. {11, 12},
  205. {12, 125},
  206. {13, 123},
  207. {21, 22},
  208. {24, 25},
  209. {25, 26},
  210. {27, 77},
  211. {28, 129},
  212. {30, 78},
  213. {31, 127},
  214. {28, 29},
  215. {34, 80},
  216. {35, 36},
  217. {36, 137},
  218. {37, 38},
  219. {10, 110},
  220. {38, 39},
  221. {39, 81},
  222. {11, 56},
  223. {12, 125},
  224. {13, 14},
  225. {23, 76},
  226. {33, 79},
  227. {40, 136},
  228. {42, 43},
  229. {43, 82},
  230. {44, 135},
  231. {45, 83},
  232. {28, 129},
  233. {46, 47},
  234. {31, 32},
  235. {47, 142},
  236. {48, 140},
  237. {47, 142},
  238. {49, 42},
  239. {50, 139},
  240. {51, 84},
  241. {52, 121},
  242. {53, 54},
  243. {54, 85},
  244. {55, 86},
  245. {56, 154},
  246. {57, 58},
  247. {58, 156},
  248. {59, 60},
  249. {60, 61},
  250. {61, 161},
  251. {62, 159},
  252. {63, 64},
  253. {64, 87},
  254. {65, 66},
  255. {66, 67},
  256. {52, 53},
  257. {67, 88},
  258. {68, 69},
  259. {2, 3},
  260. {69, 70},
  261. {5, 119},
  262. {6, 7},
  263. {70, 89},
  264. {14, 15},
  265. {71, 90},
  266. {72, 106},
  267. {17, 152},
  268. {18, 19},
  269. {0, 0},
  270. {0, 0},
  271. {0, 0},
  272. {0, 0},
  273. {0, 0},
  274. {0, 0},
  275. {0, 0},
  276. {0, 0},
  277. {0, 0},
  278. {0, 0},
  279. {0, 0},
  280. {0, 0},
  281. {0, 0},
  282. {0, 0},
  283. {0, 0},
  284. {0, 0},
  285. {0, 0},
  286. {0, 0},
  287. {0, 0},
  288. {0, 0},
  289. {0, 0},
  290. {0, 0},
  291. {0, 0},
  292. {0, 0},
  293. {0, 0},
  294. {0, 0},
  295. {0, 0},
  296. {0, 0},
  297. {0, 0},
  298. {0, 0},
  299. {0, 0},
  300. {0, 0},
  301. {0, 0},
  302. {0, 0},
  303. {0, 0},
  304. {0, 0},
  305. {0, 0},
  306. {0, 0},
  307. {0, 0},
  308. {0, 0},
  309. {0, 0},
  310. {0, 0},
  311. {0, 0},
  312. {0, 0},
  313. {0, 0},
  314. {0, 0},
  315. {0, 0},
  316. {58, 59},
  317. {0, 0},
  318. {0, 0},
  319. {0, 0},
  320. {61, 161},
  321. {62, 63},
  322. {0, 0},
  323. {0, 0},
  324. {0, 0},
  325. {0, 0},
  326. {0, 0},
  327. {0, 0},
  328. {0, 0},
  329. {0, 0},
  330. {0, 0},
  331. {0, 0},
  332. {0, 0},
  333. {0, 0},
  334. {0, 0},
  335. {0, 0},
  336. {0, 0},
  337. {0, 0},
  338. {0, 0},
  339. {0, 0},
  340. {0, 0},
  341. {0, 0},
  342. {0, 0},
  343. {0, 0},
  344. {0, 0},
  345. {0, 0},
  346. {0, 0},
  347. {0, 0},
  348. };
  349. static unsigned short yyNComb[yyNTableMax - yyLastTerminal] = {
  350. 9,
  351. 11,
  352. 101,
  353. 72,
  354. 102,
  355. 103,
  356. 104,
  357. 105,
  358. 6,
  359. 91,
  360. 13,
  361. 24,
  362. 35,
  363. 46,
  364. 52,
  365. 55,
  366. 97,
  367. 98,
  368. 28,
  369. 31,
  370. 34,
  371. 94,
  372. 95,
  373. 37,
  374. 40,
  375. 41,
  376. 44,
  377. 45,
  378. 48,
  379. 50,
  380. 96,
  381. 21,
  382. 93,
  383. 18,
  384. 92,
  385. 49,
  386. 51,
  387. 57,
  388. 68,
  389. 65,
  390. 100,
  391. 62,
  392. 99,
  393. 71,
  394. 0,
  395. 0,
  396. 0,
  397. 0,
  398. 0,
  399. };
  400. static yyTCombType *yyTBasePtr[yyLastReadState+1] = {
  401. & yyTComb [0],
  402. & yyTComb [0],
  403. & yyTComb [0],
  404. & yyTComb [0],
  405. & yyTComb [0],
  406. & yyTComb [1],
  407. & yyTComb [2],
  408. & yyTComb [4],
  409. & yyTComb [1],
  410. & yyTComb [4],
  411. & yyTComb [0],
  412. & yyTComb [3],
  413. & yyTComb [2],
  414. & yyTComb [3],
  415. & yyTComb [5],
  416. & yyTComb [7],
  417. & yyTComb [3],
  418. & yyTComb [7],
  419. & yyTComb [8],
  420. & yyTComb [13],
  421. & yyTComb [4],
  422. & yyTComb [17],
  423. & yyTComb [4],
  424. & yyTComb [3],
  425. & yyTComb [5],
  426. & yyTComb [4],
  427. & yyTComb [5],
  428. & yyTComb [4],
  429. & yyTComb [7],
  430. & yyTComb [6],
  431. & yyTComb [4],
  432. & yyTComb [9],
  433. & yyTComb [7],
  434. & yyTComb [0],
  435. & yyTComb [11],
  436. & yyTComb [7],
  437. & yyTComb [4],
  438. & yyTComb [5],
  439. & yyTComb [39],
  440. & yyTComb [7],
  441. & yyTComb [12],
  442. & yyTComb [0],
  443. & yyTComb [47],
  444. & yyTComb [13],
  445. & yyTComb [20],
  446. & yyTComb [21],
  447. & yyTComb [22],
  448. & yyTComb [22],
  449. & yyTComb [21],
  450. & yyTComb [23],
  451. & yyTComb [27],
  452. & yyTComb [28],
  453. & yyTComb [39],
  454. & yyTComb [61],
  455. & yyTComb [25],
  456. & yyTComb [42],
  457. & yyTComb [24],
  458. & yyTComb [25],
  459. & yyTComb [57],
  460. & yyTComb [59],
  461. & yyTComb [69],
  462. & yyTComb [60],
  463. & yyTComb [61],
  464. & yyTComb [63],
  465. & yyTComb [73],
  466. & yyTComb [64],
  467. & yyTComb [74],
  468. & yyTComb [35],
  469. & yyTComb [35],
  470. & yyTComb [79],
  471. & yyTComb [39],
  472. & yyTComb [45],
  473. & yyTComb [87],
  474. };
  475. static unsigned short* yyNBasePtr[yyLastReadState+1] = {
  476. & yyNComb [-82],
  477. & yyNComb [-82],
  478. & yyNComb [-82],
  479. & yyNComb [-82],
  480. & yyNComb [-82],
  481. & yyNComb [-82],
  482. & yyNComb [-82],
  483. & yyNComb [-82],
  484. & yyNComb [-82],
  485. & yyNComb [-82],
  486. & yyNComb [-82],
  487. & yyNComb [-82],
  488. & yyNComb [-82],
  489. & yyNComb [-82],
  490. & yyNComb [-82],
  491. & yyNComb [-82],
  492. & yyNComb [-82],
  493. & yyNComb [-82],
  494. & yyNComb [-82],
  495. & yyNComb [-82],
  496. & yyNComb [-82],
  497. & yyNComb [-82],
  498. & yyNComb [-82],
  499. & yyNComb [-82],
  500. & yyNComb [-82],
  501. & yyNComb [-82],
  502. & yyNComb [-82],
  503. & yyNComb [-82],
  504. & yyNComb [-82],
  505. & yyNComb [-82],
  506. & yyNComb [-82],
  507. & yyNComb [-82],
  508. & yyNComb [-82],
  509. & yyNComb [-82],
  510. & yyNComb [-82],
  511. & yyNComb [-82],
  512. & yyNComb [-82],
  513. & yyNComb [-82],
  514. & yyNComb [-82],
  515. & yyNComb [-82],
  516. & yyNComb [-82],
  517. & yyNComb [-82],
  518. & yyNComb [-82],
  519. & yyNComb [-82],
  520. & yyNComb [-82],
  521. & yyNComb [-82],
  522. & yyNComb [-82],
  523. & yyNComb [-82],
  524. & yyNComb [-76],
  525. & yyNComb [-79],
  526. & yyNComb [-76],
  527. & yyNComb [-82],
  528. & yyNComb [-82],
  529. & yyNComb [-82],
  530. & yyNComb [-82],
  531. & yyNComb [-82],
  532. & yyNComb [-80],
  533. & yyNComb [-80],
  534. & yyNComb [-81],
  535. & yyNComb [-82],
  536. & yyNComb [-82],
  537. & yyNComb [-81],
  538. & yyNComb [-81],
  539. & yyNComb [-82],
  540. & yyNComb [-82],
  541. & yyNComb [-82],
  542. & yyNComb [-82],
  543. & yyNComb [-82],
  544. & yyNComb [-76],
  545. & yyNComb [-82],
  546. & yyNComb [-82],
  547. & yyNComb [-82],
  548. & yyNComb [-82],
  549. };
  550. static unsigned short yyDefault[yyLastReadState+1] = {
  551. 0,
  552. 0,
  553. 0,
  554. 0,
  555. 0,
  556. 0,
  557. 0,
  558. 0,
  559. 0,
  560. 0,
  561. 0,
  562. 0,
  563. 0,
  564. 0,
  565. 0,
  566. 0,
  567. 0,
  568. 0,
  569. 0,
  570. 0,
  571. 0,
  572. 0,
  573. 0,
  574. 0,
  575. 0,
  576. 0,
  577. 0,
  578. 0,
  579. 0,
  580. 0,
  581. 0,
  582. 0,
  583. 0,
  584. 0,
  585. 0,
  586. 0,
  587. 0,
  588. 0,
  589. 0,
  590. 0,
  591. 0,
  592. 49,
  593. 0,
  594. 0,
  595. 0,
  596. 0,
  597. 0,
  598. 0,
  599. 37,
  600. 0,
  601. 0,
  602. 0,
  603. 0,
  604. 0,
  605. 0,
  606. 0,
  607. 0,
  608. 0,
  609. 0,
  610. 0,
  611. 0,
  612. 0,
  613. 0,
  614. 0,
  615. 0,
  616. 0,
  617. 0,
  618. 0,
  619. 0,
  620. 0,
  621. 0,
  622. 0,
  623. 0,
  624. };
  625. static unsigned char yyLength[yyLastReduceState - yyFirstReduceState+1] = {
  626. 2,
  627. 5,
  628. 0,
  629. 1,
  630. 0,
  631. 2,
  632. 1,
  633. 1,
  634. 0,
  635. 1,
  636. 5,
  637. 0,
  638. 3,
  639. 0,
  640. 8,
  641. 0,
  642. 1,
  643. 0,
  644. 1,
  645. 0,
  646. 5,
  647. 0,
  648. 1,
  649. 0,
  650. 1,
  651. 3,
  652. 3,
  653. 3,
  654. 7,
  655. 0,
  656. 0,
  657. 0,
  658. 6,
  659. 0,
  660. 0,
  661. 1,
  662. 0,
  663. 3,
  664. 3,
  665. 3,
  666. 5,
  667. 0,
  668. 1,
  669. 5,
  670. 0,
  671. 3,
  672. 0,
  673. 5,
  674. 0,
  675. 5,
  676. 0,
  677. 1,
  678. 5,
  679. 0,
  680. 3,
  681. 0,
  682. 3,
  683. };
  684. static yySymbolRange yyLeftHandSide[yyLastReduceState - yyFirstReduceState+1] = {
  685. 124,
  686. 85,
  687. 84,
  688. 84,
  689. 83,
  690. 83,
  691. 86,
  692. 86,
  693. 82,
  694. 82,
  695. 89,
  696. 91,
  697. 91,
  698. 90,
  699. 87,
  700. 97,
  701. 97,
  702. 93,
  703. 93,
  704. 92,
  705. 94,
  706. 102,
  707. 102,
  708. 101,
  709. 101,
  710. 100,
  711. 104,
  712. 103,
  713. 95,
  714. 109,
  715. 107,
  716. 105,
  717. 96,
  718. 112,
  719. 111,
  720. 111,
  721. 110,
  722. 106,
  723. 108,
  724. 98,
  725. 99,
  726. 113,
  727. 113,
  728. 114,
  729. 116,
  730. 116,
  731. 115,
  732. 88,
  733. 117,
  734. 118,
  735. 120,
  736. 120,
  737. 121,
  738. 123,
  739. 123,
  740. 122,
  741. 119,
  742. };
  743. static yySymbolRange yyContinuation[yyLastReadState+1] = {
  744. 0,
  745. 20,
  746. 11,
  747. 10,
  748. 1,
  749. 11,
  750. 11,
  751. 10,
  752. 1,
  753. 11,
  754. 0,
  755. 0,
  756. 24,
  757. 24,
  758. 11,
  759. 10,
  760. 1,
  761. 11,
  762. 11,
  763. 10,
  764. 1,
  765. 11,
  766. 2,
  767. 43,
  768. 24,
  769. 26,
  770. 2,
  771. 27,
  772. 25,
  773. 2,
  774. 29,
  775. 25,
  776. 2,
  777. 47,
  778. 25,
  779. 30,
  780. 34,
  781. 34,
  782. 2,
  783. 35,
  784. 36,
  785. 36,
  786. 2,
  787. 37,
  788. 31,
  789. 31,
  790. 32,
  791. 34,
  792. 36,
  793. 36,
  794. 33,
  795. 33,
  796. 23,
  797. 2,
  798. 39,
  799. 23,
  800. 42,
  801. 42,
  802. 11,
  803. 10,
  804. 1,
  805. 11,
  806. 11,
  807. 10,
  808. 1,
  809. 11,
  810. 2,
  811. 43,
  812. 44,
  813. 2,
  814. 45,
  815. 41,
  816. 0,
  817. };
  818. static unsigned short yyFinalToProd[yyLastReadNontermState - yyFirstReadTermState+1] = {
  819. 118,
  820. 109,
  821. 151,
  822. 146,
  823. 131,
  824. 132,
  825. 133,
  826. 126,
  827. 143,
  828. 144,
  829. 134,
  830. 138,
  831. 145,
  832. 120,
  833. 160,
  834. 155,
  835. 162,
  836. 153,
  837. 116,
  838. 149,
  839. 148,
  840. 128,
  841. 130,
  842. 141,
  843. 122,
  844. 124,
  845. 158,
  846. 157,
  847. 107,
  848. 111,
  849. 112,
  850. 113,
  851. 115,
  852. };
  853.  
  854.  
  855. static void yyErrorRecovery(yySymbolRange * yyTerminal, yyStateRange * yyStateStack, unsigned long yyStackSize, short yyStackPtr);
  856. static void yyComputeContinuation(yyStateRange * yyStack, unsigned long yyStackSize, short yyStackPtr, tSet * yyContinueSet);
  857. static bool yyIsContinuation(yySymbolRange yyTerminal, yyStateRange * yyStateStack, unsigned long yyStackSize, short yyStackPtr);
  858. static void yyComputeRestartPoints(yyStateRange * yyStateStack, unsigned long yyStackSize, short yyStackPtr, tSet * yyRestartSet);
  859. static yyStateRange yyNext(yyStateRange yyState, yySymbolRange yySymbol);
  860. static void BeginPhoneLogParser(void);
  861.  
  862.  
  863. int PhoneLogParser(void)
  864.  {
  865.   register yyStateRange yyState;
  866.   register long yyTerminal;
  867.   register yyStateRange *yyStateStackPtr;
  868.   register tParsAttribute *yyAttrStackPtr;
  869.   register bool yyIsRepairing;
  870.   unsigned long yyStateStackSize= yyInitStackSize;
  871.   unsigned long yyAttrStackSize = yyInitStackSize;
  872.   yyStateRange *yyStateStack;
  873.   tParsAttribute* yyAttributeStack;
  874.   tParsAttribute yySynAttribute; /* synthesized attribute */ /* ??? */
  875.   register yyStateRange *yyEndOfStack;
  876.   int yyErrorCount = 0;
  877.  
  878. /* line 25 "t:lalr.tmp" */
  879. /* line 25 "PhoneLogParser.lalr" */
  880. /*LOCAL*/
  881.        char Word[256];
  882.        /*LOCAL*/
  883.  
  884.  BeginPhoneLogParser();
  885.   yyState = yyStartState;
  886.  yyTerminal = PhoneLogScanner_GetToken();
  887.   MakeArray((char **)&yyStateStack,&yyStateStackSize,sizeof(yyStateRange));
  888.   MakeArray((char **)&yyAttributeStack,&yyAttrStackSize,sizeof(tParsAttribute));
  889.   yyEndOfStack      = &yyStateStack[yyStateStackSize];
  890.   yyStateStackPtr   = yyStateStack;
  891.   yyAttrStackPtr    = yyAttributeStack;
  892.   yyIsRepairing     = false;
  893. ParseLoop:
  894.   for (;;)
  895.    {
  896.     if (yyStateStackPtr >= yyEndOfStack)
  897.      {
  898.       int yyyStateStackPtr = yyStateStackPtr - yyStateStack;
  899.       int yyyAttrStackPtr = yyAttrStackPtr - yyAttributeStack;
  900.       ExtendArray ((char **)&yyStateStack,&yyStateStackSize,sizeof (yyStateRange));
  901.       ExtendArray ((char **)&yyAttributeStack,&yyAttrStackSize,sizeof (tParsAttribute));
  902.       yyStateStackPtr = yyStateStack + yyyStateStackPtr;
  903.       yyAttrStackPtr = yyAttributeStack + yyyAttrStackPtr;
  904.       yyEndOfStack = &yyStateStack[yyStateStackSize];
  905.      }
  906.     *yyStateStackPtr = yyState;
  907. TermTrans:
  908.     for (;;)
  909.      {/* SPEC State = Next (State, Terminal); terminal transition */
  910.       register short *yyTCombPtr;
  911.  
  912.       yyTCombPtr = (short *)(yyTBasePtr[yyState] + yyTerminal);
  913.       if (*yyTCombPtr++ == yyState)
  914.        {
  915.         yyState = *yyTCombPtr;
  916.         break;
  917.        }
  918.       if ((yyState = yyDefault[yyState]) != yyNoState)
  919.         goto TermTrans;
  920.       /* syntax error */
  921.       if (!yyIsRepairing)
  922.        {/* report and recover */
  923.         yySymbolRange yyyTerminal = yyTerminal;
  924.         yyErrorCount++;
  925.         yyErrorRecovery(&yyyTerminal,yyStateStack,yyStateStackSize,(short)(yyStateStackPtr-yyStateStack));
  926.         yyTerminal = yyyTerminal;
  927.         yyIsRepairing = true;
  928.        }
  929.       yyState = *yyStateStackPtr;
  930.       for (;;)
  931.        {
  932.         if (yyNext(yyState,(yySymbolRange)yyTerminal) == yyNoState)
  933.          {/* repair */
  934.           yySymbolRange yyRepairToken;
  935.          PhoneLogScanner_tScanAttribute yyRepairAttribute;
  936.             yyRepairToken = yyContinuation[yyState];
  937.             yyState = yyNext(yyState, yyRepairToken);
  938.             if (yyState <= yyLastReadTermState)
  939.              {/* read or read terminal reduce ? */
  940.              PhoneLogScanner_ErrorAttribute((int)yyRepairToken,&yyRepairAttribute);
  941.              ErrorMessageI(xxTokenInserted,xxRepair,PhoneLogScanner_Attribute.Position,xxString,PhoneLogParser_TokenName[yyRepairToken]);
  942.               if (yyState >= yyFirstFinalState)
  943.                {/* avoid second push */
  944.                 yyState = yyFinalToProd[yyState - yyFirstReadTermState];
  945.                }
  946.               yyGetAttribute(yyAttrStackPtr++,yyRepairAttribute);
  947.               * ++yyStateStackPtr = yyState;
  948.              }
  949.             if (yyState >= yyFirstFinalState)
  950.               goto Final; /* final state ? */
  951.            }
  952.           else
  953.            {
  954.             yyState = yyNext(yyState,(yySymbolRange)yyTerminal);
  955.             goto Final;
  956.            }
  957.          }
  958.        }
  959. Final:
  960.       if (yyState >= yyFirstFinalState)
  961.        {/* final state ? */
  962.         if (yyState <= yyLastReadTermState)
  963.          {/* read terminal reduce ? */
  964.           yyStateStackPtr++;
  965.          yyGetAttribute(yyAttrStackPtr++,PhoneLogScanner_Attribute);
  966.          yyTerminal = PhoneLogScanner_GetToken();
  967.             yyIsRepairing = false;
  968.          }
  969.         for (;;)
  970.          {/* left-hand side */
  971.           #define yyNonterminal yyState
  972.  
  973. switch (yyState) {
  974. case 106: /* _0000_ : PHONELOG _EndOfFile .*/
  975.   ReleaseArray ((char * *) & yyStateStack, & yyStateStackSize, sizeof (yyStateRange));
  976.   ReleaseArray ((char * *) & yyAttributeStack, & yyAttrStackSize, sizeof (tParsAttribute));
  977.   return yyErrorCount;
  978.  
  979. case 107:
  980. case 101: /* PHONELOG : "<PHONELOG" PHONELOG_1 ">" PHONELOG_2 PHONELOG_3 .*/
  981.   yyStateStackPtr -=5; yyAttrStackPtr -=5; yyNonterminal = 85; {
  982.  
  983. } break;
  984. case 108: /* PHONELOG_3 : .*/
  985.   yyStateStackPtr -=0; yyAttrStackPtr -=0; yyNonterminal = 84; {
  986.  
  987. } break;
  988. case 109:
  989. case 74: /* PHONELOG_3 : "</PHONELOG>" .*/
  990.   yyStateStackPtr -=1; yyAttrStackPtr -=1; yyNonterminal = 84; {
  991.  
  992. } break;
  993. case 110: /* PHONELOG_2 : .*/
  994.   yyStateStackPtr -=0; yyAttrStackPtr -=0; yyNonterminal = 83; {
  995.  
  996. } break;
  997. case 111:
  998. case 102: /* PHONELOG_2 : PHONELOG_2 PHONELOG_4 .*/
  999.   yyStateStackPtr -=2; yyAttrStackPtr -=2; yyNonterminal = 83; {
  1000.  
  1001. } break;
  1002. case 112:
  1003. case 103: /* PHONELOG_4 : ENTRY .*/
  1004.   yyStateStackPtr -=1; yyAttrStackPtr -=1; yyNonterminal = 86; {
  1005.  
  1006. } break;
  1007. case 113:
  1008. case 104: /* PHONELOG_4 : MARK .*/
  1009.   yyStateStackPtr -=1; yyAttrStackPtr -=1; yyNonterminal = 86; {
  1010.  
  1011. } break;
  1012. case 114: /* PHONELOG_1 : .*/
  1013.   yyStateStackPtr -=0; yyAttrStackPtr -=0; yyNonterminal = 82; {
  1014.  
  1015. } break;
  1016. case 115:
  1017. case 105: /* PHONELOG_1 : PHONELOGATTR .*/
  1018.   yyStateStackPtr -=1; yyAttrStackPtr -=1; yyNonterminal = 82; {
  1019.  
  1020. } break;
  1021. case 116:
  1022. case 91: /* PHONELOGATTR : "version" "=" digits PHONELOGATTR_1 PHONELOGATTR_2 .*/
  1023.   yyStateStackPtr -=5; yyAttrStackPtr -=5; yyNonterminal = 89; {
  1024.  
  1025. } break;
  1026. case 117: /* PHONELOGATTR_2 : .*/
  1027.   yyStateStackPtr -=0; yyAttrStackPtr -=0; yyNonterminal = 91; {
  1028.  
  1029. } break;
  1030. case 118:
  1031. case 73: /* PHONELOGATTR_2 : "revision" "=" digits .*/
  1032.   yyStateStackPtr -=3; yyAttrStackPtr -=3; yyNonterminal = 91; {
  1033. /* line 89 "t:lalr.tmp" */
  1034. /* line 100 "PhoneLogParser.lalr" */
  1035.  
  1036.                    #ifdef DEBUG
  1037.                      printf("PhoneLog revision: %d\n",yyAttrStackPtr [3-1].Scan.number);
  1038.                    #endif
  1039.                     if ((yyAttrStackPtr [-1-1].Scan.number == 1) && (yyAttrStackPtr [3-1].Scan.number != 1))
  1040.                      {
  1041.                       ErrorMessage(xxSyntaxError,xxFatal,yyAttrStackPtr [3-1].Scan.Position);
  1042.                      }
  1043.                    
  1044. } break;
  1045. case 119: /* PHONELOGATTR_1 : .*/
  1046.   yyStateStackPtr -=0; yyAttrStackPtr -=0; yyNonterminal = 90; {
  1047. /* line 101 "t:lalr.tmp" */
  1048. /* line 89 "PhoneLogParser.lalr" */
  1049.  
  1050.                    #ifdef DEBUG
  1051.                      printf("PhoneLog version : %d\n",yyAttrStackPtr [0-1].Scan.number);
  1052.                    #endif
  1053.                    if (yyAttrStackPtr [0-1].Scan.number != 1)
  1054.                     {
  1055.                      ErrorMessage(xxSyntaxError,xxFatal,yyAttrStackPtr [0-1].Scan.Position);
  1056.                     }
  1057.                   
  1058. } break;
  1059. case 120:
  1060. case 86: /* ENTRY : "<ENTRY>" ENTRY_1 ENTRY_2 HOST START END ENTRY_3 "</ENTRY>" .*/
  1061.   yyStateStackPtr -=8; yyAttrStackPtr -=8; yyNonterminal = 87; {
  1062. /* line 111 "t:lalr.tmp" */
  1063. /* line 139 "PhoneLogParser.lalr" */
  1064.  
  1065.                    InsertPhoneLogEntry(&Entry);
  1066.                   
  1067. } break;
  1068. case 121: /* ENTRY_3 : .*/
  1069.   yyStateStackPtr -=0; yyAttrStackPtr -=0; yyNonterminal = 97; {
  1070.  
  1071. } break;
  1072. case 122:
  1073. case 97: /* ENTRY_3 : PERIOD .*/
  1074.   yyStateStackPtr -=1; yyAttrStackPtr -=1; yyNonterminal = 97; {
  1075.  
  1076. } break;
  1077. case 123: /* ENTRY_2 : .*/
  1078.   yyStateStackPtr -=0; yyAttrStackPtr -=0; yyNonterminal = 93; {
  1079.  
  1080. } break;
  1081. case 124:
  1082. case 98: /* ENTRY_2 : PROGRAM1 .*/
  1083.   yyStateStackPtr -=1; yyAttrStackPtr -=1; yyNonterminal = 93; {
  1084.  
  1085. } break;
  1086. case 125: /* ENTRY_1 : .*/
  1087.   yyStateStackPtr -=0; yyAttrStackPtr -=0; yyNonterminal = 92; {
  1088. /* line 145 "t:lalr.tmp" */
  1089. /* line 134 "PhoneLogParser.lalr" */
  1090.  
  1091.                    Entry.Number[0] = '\0';
  1092.                    Entry.Name[0] = '\0';
  1093.                    Entry.Reason[0] = '\0';
  1094.                    Entry.ProgramName[0] = '\0';
  1095.                    Entry.ProgramVersion = 0;
  1096.                    Entry.ProgramRevision = 0;
  1097.                    Entry.StartDay = 0;
  1098.                    Entry.StartMonth = 0;
  1099.                    Entry.StartYear = 0;
  1100.                    Entry.StartHour = 0;
  1101.                    Entry.StartMin = 0;
  1102.                    Entry.StartSec = 0;
  1103.                    Entry.EndDay = 0;
  1104.                    Entry.EndMonth = 0;
  1105.                    Entry.EndYear = 0;
  1106.                    Entry.EndHour = 0;
  1107.                    Entry.EndMin = 0;
  1108.                    Entry.EndSec = 0;
  1109.                    Entry.Hours = 0;
  1110.                    Entry.Mins = 0;
  1111.                    Entry.Secs = 0;
  1112.                    #ifdef DEBUG
  1113.                      printf("\nENTRY\n");
  1114.                    #endif
  1115.                   
  1116. } break;
  1117. case 126:
  1118. case 80: /* HOST : "<HOST>" NUMBER HOST_1 HOST_2 "</HOST>" .*/
  1119.   yyStateStackPtr -=5; yyAttrStackPtr -=5; yyNonterminal = 94; {
  1120.  
  1121. } break;
  1122. case 127: /* HOST_2 : .*/
  1123.   yyStateStackPtr -=0; yyAttrStackPtr -=0; yyNonterminal = 102; {
  1124.  
  1125. } break;
  1126. case 128:
  1127. case 94: /* HOST_2 : REASON .*/
  1128.   yyStateStackPtr -=1; yyAttrStackPtr -=1; yyNonterminal = 102; {
  1129.  
  1130. } break;
  1131. case 129: /* HOST_1 : .*/
  1132.   yyStateStackPtr -=0; yyAttrStackPtr -=0; yyNonterminal = 101; {
  1133.  
  1134. } break;
  1135. case 130:
  1136. case 95: /* HOST_1 : HOSTNAME .*/
  1137.   yyStateStackPtr -=1; yyAttrStackPtr -=1; yyNonterminal = 101; {
  1138.  
  1139. } break;
  1140. case 131:
  1141. case 77: /* NUMBER : "<NUMBER>" text "</NUMBER>" .*/
  1142.   yyStateStackPtr -=3; yyAttrStackPtr -=3; yyNonterminal = 100; {
  1143. /* line 170 "t:lalr.tmp" */
  1144. /* line 160 "PhoneLogParser.lalr" */
  1145.  
  1146.                    StGetString(yyAttrStackPtr [2-1].Scan.lexstring,Word);
  1147.                    if (strlen(Word) < 31)
  1148.                     {
  1149.                      strcpy(Entry.Number,Word);
  1150.                     }
  1151.                    else
  1152.                     {
  1153.                      strncpy(Entry.Number,Word,30);
  1154.                      Entry.Number[30] = '\0';
  1155.                     }
  1156.                    #ifdef DEBUG
  1157.                      printf("  NUMBER  : %s\n",Word);
  1158.                    #endif
  1159.                   
  1160. } break;
  1161. case 132:
  1162. case 78: /* HOSTNAME : "<HOSTNAME>" text "</HOSTNAME>" .*/
  1163.   yyStateStackPtr -=3; yyAttrStackPtr -=3; yyNonterminal = 104; {
  1164. /* line 189 "t:lalr.tmp" */
  1165. /* line 178 "PhoneLogParser.lalr" */
  1166.  
  1167.                    StGetString(yyAttrStackPtr [2-1].Scan.lexstring,Word);
  1168.                    if (strlen(Word) < 81)
  1169.                     {
  1170.                      strcpy(Entry.Name,Word);
  1171.                     }
  1172.                    else
  1173.                     {
  1174.                      strncpy(Entry.Name,Word,80);
  1175.                      Entry.Name[80] = '\0';
  1176.                     }
  1177.                    #ifdef DEBUG
  1178.                      printf("  HOSTNAME: %s\n",Word);
  1179.                    #endif
  1180.                   
  1181. } break;
  1182. case 133:
  1183. case 79: /* REASON : "<REASON>" text "</REASON>" .*/
  1184.   yyStateStackPtr -=3; yyAttrStackPtr -=3; yyNonterminal = 103; {
  1185. /* line 208 "t:lalr.tmp" */
  1186. /* line 196 "PhoneLogParser.lalr" */
  1187.  
  1188.                    StGetString(yyAttrStackPtr [2-1].Scan.lexstring,Word);
  1189.                    if (strlen(Word) < 81)
  1190.                     {
  1191.                      strcpy(Entry.Reason,Word);
  1192.                     }
  1193.                    else
  1194.                     {
  1195.                      strncpy(Entry.Reason,Word,80);
  1196.                      Entry.Reason[0] = '\0';
  1197.                     }
  1198.                    #ifdef DEBUG
  1199.                      printf("  REASON: %s\n",Word);
  1200.                    #endif
  1201.                   
  1202. } break;
  1203. case 134:
  1204. case 83: /* START : "<START>" START_1 DATE START_2 TIME START_3 "</START>" .*/
  1205.   yyStateStackPtr -=7; yyAttrStackPtr -=7; yyNonterminal = 95; {
  1206.  
  1207. } break;
  1208. case 135: /* START_3 : .*/
  1209.   yyStateStackPtr -=0; yyAttrStackPtr -=0; yyNonterminal = 109; {
  1210. /* line 215 "t:lalr.tmp" */
  1211. /* line 215 "PhoneLogParser.lalr" */
  1212.  
  1213.                    Entry.StartHour = Hour;
  1214.                    Entry.StartMin = Min;
  1215.                    Entry.StartSec = Sec;
  1216.                   
  1217. } break;
  1218. case 136: /* START_2 : .*/
  1219.   yyStateStackPtr -=0; yyAttrStackPtr -=0; yyNonterminal = 107; {
  1220. /* line 223 "t:lalr.tmp" */
  1221. /* line 208 "PhoneLogParser.lalr" */
  1222.  
  1223.                    Entry.StartDay = Day;
  1224.                    Entry.StartMonth = Month;
  1225.                    Entry.StartYear = Year;
  1226.                   
  1227. } break;
  1228. case 137: /* START_1 : .*/
  1229.   yyStateStackPtr -=0; yyAttrStackPtr -=0; yyNonterminal = 105; {
  1230. /* line 234 "t:lalr.tmp" */
  1231. /* line 204 "PhoneLogParser.lalr" */
  1232.  
  1233.                    #ifdef DEBUG
  1234.                      printf("  START\n");
  1235.                    #endif
  1236.                   
  1237. } break;
  1238. case 138:
  1239. case 84: /* END : "<END>" END_1 END_2 TIME END_3 "</END>" .*/
  1240.   yyStateStackPtr -=6; yyAttrStackPtr -=6; yyNonterminal = 96; {
  1241.  
  1242. } break;
  1243. case 139: /* END_3 : .*/
  1244.   yyStateStackPtr -=0; yyAttrStackPtr -=0; yyNonterminal = 112; {
  1245. /* line 241 "t:lalr.tmp" */
  1246. /* line 241 "PhoneLogParser.lalr" */
  1247.  
  1248.                    Entry.EndHour = Hour;
  1249.                    Entry.EndMin = Min;
  1250.                    Entry.EndSec = Sec;
  1251.                   
  1252. } break;
  1253. case 140: /* END_2 : .*/
  1254.   yyStateStackPtr -=0; yyAttrStackPtr -=0; yyNonterminal = 111; {
  1255.  
  1256. } break;
  1257. case 141:
  1258. case 96: /* END_2 : DATE .*/
  1259.   yyStateStackPtr -=1; yyAttrStackPtr -=1; yyNonterminal = 111; {
  1260. /* line 250 "t:lalr.tmp" */
  1261. /* line 234 "PhoneLogParser.lalr" */
  1262.  
  1263.                    Entry.EndDay = Day;
  1264.                    Entry.EndMonth = Month;
  1265.                    Entry.EndYear = Year;
  1266.                   
  1267. } break;
  1268. case 142: /* END_1 : .*/
  1269.   yyStateStackPtr -=0; yyAttrStackPtr -=0; yyNonterminal = 110; {
  1270. /* line 264 "t:lalr.tmp" */
  1271. /* line 229 "PhoneLogParser.lalr" */
  1272.  
  1273.                    Entry.EndDay = Entry.StartDay;
  1274.                    Entry.EndMonth = Entry.StartMonth;
  1275.                    Entry.EndYear = Entry.StartYear;
  1276.                    #ifdef DEBUG
  1277.                      printf("  END\n");
  1278.                    #endif
  1279.                   
  1280. } break;
  1281. case 143:
  1282. case 81: /* DATE : "<DATE>" text "</DATE>" .*/
  1283.   yyStateStackPtr -=3; yyAttrStackPtr -=3; yyNonterminal = 106; {
  1284. /* line 275 "t:lalr.tmp" */
  1285. /* line 254 "PhoneLogParser.lalr" */
  1286.  
  1287.                    StGetString(yyAttrStackPtr [2-1].Scan.lexstring,Word);
  1288.                    sscanf(Word,"%d-%hu-%hu",&Year,&Month,&Day);
  1289.                    #ifdef DEBUG
  1290.                      printf("    DATE  : %hu.%hu.%d\n",Day,Month,Year);
  1291.                    #endif
  1292.                   
  1293. } break;
  1294. case 144:
  1295. case 82: /* TIME : "<TIME>" text "</TIME>" .*/
  1296.   yyStateStackPtr -=3; yyAttrStackPtr -=3; yyNonterminal = 108; {
  1297. /* line 286 "t:lalr.tmp" */
  1298. /* line 264 "PhoneLogParser.lalr" */
  1299.  
  1300.                    StGetString(yyAttrStackPtr [2-1].Scan.lexstring,Word);
  1301.                    sscanf(Word,"%hu:%hu:%hu",&Hour,&Min,&Sec);
  1302.                    #ifdef DEBUG
  1303.                      printf("    TIME  : %hu:%hu:%hu\n",Hour,Min,Sec);
  1304.                    #endif
  1305.                   
  1306. } break;
  1307. case 145:
  1308. case 85: /* PERIOD : "<PERIOD>" text "</PERIOD>" .*/
  1309.   yyStateStackPtr -=3; yyAttrStackPtr -=3; yyNonterminal = 98; {
  1310. /* line 317 "t:lalr.tmp" */
  1311. /* line 294 "PhoneLogParser.lalr" */
  1312.  
  1313.                    /*
  1314.                    char *h,*m,*s;
  1315.  
  1316.                    Entry.Hours = 0;
  1317.                    Entry.Mins = 0;
  1318.                    Entry.Secs = 0;
  1319.                    StGetString(yyAttrStackPtr [2-1].Scan.lexstring,Word);
  1320.                    h = strchr(Word,(int)'H');
  1321.                    m = strchr(Word,(int)'M');
  1322.                    s = strchr(Word,(int)'S');
  1323.                    if (h != NULL)
  1324.                     {
  1325.                      Entry.Hours = atoi(Word);
  1326.                     }
  1327.                    if (m != NULL)
  1328.                     {
  1329.                      Entry.Mins = atoi(++h);
  1330.                     }
  1331.                    if (s != NULL)
  1332.                     {
  1333.                      Entry.Secs = atoi(++m);
  1334.                     }
  1335.                    #ifdef DEBUG
  1336.                      printf("  PERIOD  : %huH%huM%huS\n",Entry.Hours,Entry.Mins,Entry.Secs);
  1337.                    #endif
  1338.                    */
  1339.                   
  1340. } break;
  1341. case 146:
  1342. case 76: /* PROGRAM1 : "<PROGRAM" PROGRAM1_1 ">" text "</PROGRAM>" .*/
  1343.   yyStateStackPtr -=5; yyAttrStackPtr -=5; yyNonterminal = 99; {
  1344. /* line 337 "t:lalr.tmp" */
  1345. /* line 314 "PhoneLogParser.lalr" */
  1346.  
  1347.                    StGetString(yyAttrStackPtr [4-1].Scan.lexstring,Word);
  1348.                    if (strlen(Word) < 32)
  1349.                     {
  1350.                      strcpy(Entry.ProgramName,Word);
  1351.                     }
  1352.                    else
  1353.                     {
  1354.                      strncpy(Entry.ProgramName,Word,31);
  1355.                      Entry.ProgramName[31] = '\0';
  1356.                     }
  1357.                    #ifdef DEBUG
  1358.                      printf("  PROGRAM         : %s\n",Word);
  1359.                    #endif
  1360.                   
  1361. } break;
  1362. case 147: /* PROGRAM1_1 : .*/
  1363.   yyStateStackPtr -=0; yyAttrStackPtr -=0; yyNonterminal = 113; {
  1364.  
  1365. } break;
  1366. case 148:
  1367. case 93: /* PROGRAM1_1 : PROGRAM1ATTR .*/
  1368.   yyStateStackPtr -=1; yyAttrStackPtr -=1; yyNonterminal = 113; {
  1369.  
  1370. } break;
  1371. case 149:
  1372. case 92: /* PROGRAM1ATTR : "version" "=" digits PROGRAM1ATTR_1 PROGRAM1ATTR_2 .*/
  1373.   yyStateStackPtr -=5; yyAttrStackPtr -=5; yyNonterminal = 114; {
  1374.  
  1375. } break;
  1376. case 150: /* PROGRAM1ATTR_2 : .*/
  1377.   yyStateStackPtr -=0; yyAttrStackPtr -=0; yyNonterminal = 116; {
  1378.  
  1379. } break;
  1380. case 151:
  1381. case 75: /* PROGRAM1ATTR_2 : "revision" "=" digits .*/
  1382.   yyStateStackPtr -=3; yyAttrStackPtr -=3; yyNonterminal = 116; {
  1383. /* line 351 "t:lalr.tmp" */
  1384. /* line 331 "PhoneLogParser.lalr" */
  1385.  
  1386.                     Entry.ProgramRevision = (unsigned short)yyAttrStackPtr [3-1].Scan.number;
  1387.                     #ifdef DEBUG
  1388.                       printf("  PROGRAM revision: %d\n",yyAttrStackPtr [3-1].Scan.number);
  1389.                     #endif
  1390.                    
  1391. } break;
  1392. case 152: /* PROGRAM1ATTR_1 : .*/
  1393.   yyStateStackPtr -=0; yyAttrStackPtr -=0; yyNonterminal = 115; {
  1394. /* line 360 "t:lalr.tmp" */
  1395. /* line 323 "PhoneLogParser.lalr" */
  1396.  
  1397.                    Entry.ProgramVersion = (unsigned short)yyAttrStackPtr [0-1].Scan.number;
  1398.                    #ifdef DEBUG
  1399.                      printf("  PROGRAM version : %d\n",yyAttrStackPtr [0-1].Scan.number);
  1400.                    #endif
  1401.                   
  1402. } break;
  1403. case 153:
  1404. case 90: /* MARK : "<MARK>" MARK_1 PROGRAM2 MARKNAME "</MARK>" .*/
  1405.   yyStateStackPtr -=5; yyAttrStackPtr -=5; yyNonterminal = 88; {
  1406. /* line 366 "t:lalr.tmp" */
  1407. /* line 350 "PhoneLogParser.lalr" */
  1408.  
  1409.                    InsertPhoneLogMark(&Marker);
  1410.                   
  1411. } break;
  1412. case 154: /* MARK_1 : .*/
  1413.   yyStateStackPtr -=0; yyAttrStackPtr -=0; yyNonterminal = 117; {
  1414. /* line 379 "t:lalr.tmp" */
  1415. /* line 345 "PhoneLogParser.lalr" */
  1416.  
  1417.                    Marker.ProgramName[0] = '\0';
  1418.                    Marker.ProgramVersion = 0;
  1419.                    Marker.ProgramRevision = 0;
  1420.                    Marker.MarkName[0] = '\0';
  1421.                    #ifdef DEBUG
  1422.                      printf("\nMARK\n");
  1423.                    #endif
  1424.                   
  1425. } break;
  1426. case 155:
  1427. case 88: /* PROGRAM2 : "<PROGRAM" PROGRAM2_1 ">" text "</PROGRAM>" .*/
  1428.   yyStateStackPtr -=5; yyAttrStackPtr -=5; yyNonterminal = 118; {
  1429. /* line 398 "t:lalr.tmp" */
  1430. /* line 368 "PhoneLogParser.lalr" */
  1431.  
  1432.                    StGetString(yyAttrStackPtr [4-1].Scan.lexstring,Word);
  1433.                    if (strlen(Word) < 32)
  1434.                     {
  1435.                      strcpy(Marker.ProgramName,Word);
  1436.                     }
  1437.                    else
  1438.                     {
  1439.                      strncpy(Marker.ProgramName,Word,31);
  1440.                      Marker.ProgramName[31] = '\0';
  1441.                     }
  1442.                    #ifdef DEBUG
  1443.                      printf("  PROGRAM         : %s\n",Word);
  1444.                    #endif
  1445.                   
  1446. } break;
  1447. case 156: /* PROGRAM2_1 : .*/
  1448.   yyStateStackPtr -=0; yyAttrStackPtr -=0; yyNonterminal = 120; {
  1449.  
  1450. } break;
  1451. case 157:
  1452. case 100: /* PROGRAM2_1 : PROGRAM2ATTR .*/
  1453.   yyStateStackPtr -=1; yyAttrStackPtr -=1; yyNonterminal = 120; {
  1454.  
  1455. } break;
  1456. case 158:
  1457. case 99: /* PROGRAM2ATTR : "version" "=" digits PROGRAM2ATTR_1 PROGRAM2ATTR_2 .*/
  1458.   yyStateStackPtr -=5; yyAttrStackPtr -=5; yyNonterminal = 121; {
  1459.  
  1460. } break;
  1461. case 159: /* PROGRAM2ATTR_2 : .*/
  1462.   yyStateStackPtr -=0; yyAttrStackPtr -=0; yyNonterminal = 123; {
  1463.  
  1464. } break;
  1465. case 160:
  1466. case 87: /* PROGRAM2ATTR_2 : "revision" "=" digits .*/
  1467.   yyStateStackPtr -=3; yyAttrStackPtr -=3; yyNonterminal = 123; {
  1468. /* line 412 "t:lalr.tmp" */
  1469. /* line 385 "PhoneLogParser.lalr" */
  1470.  
  1471.                     Marker.ProgramRevision = (unsigned short)yyAttrStackPtr [3-1].Scan.number;
  1472.                     #ifdef DEBUG
  1473.                       printf("  PROGRAM revision: %d\n",yyAttrStackPtr [3-1].Scan.number);
  1474.                     #endif
  1475.                    
  1476. } break;
  1477. case 161: /* PROGRAM2ATTR_1 : .*/
  1478.   yyStateStackPtr -=0; yyAttrStackPtr -=0; yyNonterminal = 122; {
  1479. /* line 421 "t:lalr.tmp" */
  1480. /* line 377 "PhoneLogParser.lalr" */
  1481.  
  1482.                    Marker.ProgramVersion = (unsigned short)yyAttrStackPtr [0-1].Scan.number;
  1483.                    #ifdef DEBUG
  1484.                      printf("  PROGRAM version : %d\n",yyAttrStackPtr [0-1].Scan.number);
  1485.                    #endif
  1486.                   
  1487. } break;
  1488. case 162:
  1489. case 89: /* MARKNAME : "<MARKNAME>" text "</MARKNAME>" .*/
  1490.   yyStateStackPtr -=3; yyAttrStackPtr -=3; yyNonterminal = 119; {
  1491. /* line 440 "t:lalr.tmp" */
  1492. /* line 404 "PhoneLogParser.lalr" */
  1493.  
  1494.                    StGetString(yyAttrStackPtr [2-1].Scan.lexstring,Word);
  1495.                    if (strlen(Word) < 256)
  1496.                     {
  1497.                      strcpy(Marker.MarkName,Word);
  1498.                     }
  1499.                    else
  1500.                     {
  1501.                      strncpy(Marker.MarkName,Word,255);
  1502.                      Marker.MarkName[255] = '\0';
  1503.                     }
  1504.                    #ifdef DEBUG
  1505.                      printf("  MARKNAME        : %s\n",Word);
  1506.                    #endif
  1507.                   
  1508. } break;
  1509. }
  1510.           /* SPEC State = Next(Top(),Nonterminal); nonterminal transition */
  1511.           yyState = *(yyNBasePtr[*yyStateStackPtr++] + yyNonterminal);
  1512.           *yyAttrStackPtr++ = yySynAttribute; /* ??? */
  1513.           if (yyState < yyFirstFinalState)
  1514.             goto ParseLoop; /* read nonterminal reduce ? */
  1515.          }
  1516.        }
  1517.       else
  1518.        {/* read */
  1519.         yyStateStackPtr++;
  1520.        yyGetAttribute(yyAttrStackPtr++,PhoneLogScanner_Attribute);
  1521.        yyTerminal = PhoneLogScanner_GetToken();
  1522.         yyIsRepairing = false;
  1523.        }
  1524.      }
  1525.  }
  1526.  
  1527.  
  1528. static void yyErrorRecovery(yySymbolRange *yyTerminal, yyStateRange *yyStateStack, unsigned long yyStackSize, short yyStackPtr)
  1529.  {
  1530.   bool yyTokensSkipped;
  1531.   tSet yyContinueSet;
  1532.   tSet yyRestartSet;
  1533.   int yyLength = 0;
  1534.   char yyContinueString[256];
  1535.  
  1536.   /* 1. report an error */
  1537.  ErrorMessage(xxSyntaxError,xxError,PhoneLogScanner_Attribute.Position);
  1538.   /* 2. report the set of expected terminal symbols */
  1539.   MakeSet(&yyContinueSet,(short)yyLastTerminal);
  1540.   yyComputeContinuation(yyStateStack,yyStackSize,yyStackPtr,&yyContinueSet);
  1541.   yyContinueString[0] = '\0';
  1542.   while (!IsEmpty(&yyContinueSet))
  1543.    {
  1544.    char *yyTokenString = PhoneLogParser_TokenName[Extract(&yyContinueSet)];
  1545.     if ((yyLength += strlen(yyTokenString)+1) >= 256)
  1546.       break;
  1547.     strcat(yyContinueString,yyTokenString);
  1548.     strcat(yyContinueString," ");
  1549.    }
  1550.  ErrorMessageI(xxExpectedTokens,xxInformation,PhoneLogScanner_Attribute.Position,xxString,yyContinueString);
  1551.   ReleaseSet(&yyContinueSet);
  1552.   /* 3. compute the set of terminal symbols for restart of the parse */
  1553.   MakeSet(&yyRestartSet,(short)yyLastTerminal);
  1554.   yyComputeRestartPoints(yyStateStack,yyStackSize,yyStackPtr,&yyRestartSet);
  1555.   /* 4. skip terminal symbols until a restart point is reached */
  1556.   yyTokensSkipped = false;
  1557.   while (!IsElement(*yyTerminal,&yyRestartSet))
  1558.    {
  1559.    *yyTerminal = PhoneLogScanner_GetToken();
  1560.     yyTokensSkipped = true;
  1561.    }
  1562.   ReleaseSet(&yyRestartSet);
  1563.   /* 5. report the restart point */
  1564.   if (yyTokensSkipped)
  1565.    {
  1566.    ErrorMessage(xxRestartPoint,xxInformation,PhoneLogScanner_Attribute.Position);
  1567.    }
  1568.  }
  1569.  
  1570.  
  1571. /* compute the set of terminal symbols that can be accepted (read)
  1572.    in a given stack configuration (eventually after reduce actions) */
  1573.  
  1574. static void yyComputeContinuation(yyStateRange *yyStack, unsigned long yyStackSize, short yyStackPtr, tSet *yyContinueSet)
  1575.  {
  1576.   register yySymbolRange yyTerminal;
  1577.   register yyStateRange yyState = yyStack[yyStackPtr];
  1578.  
  1579.   AssignEmpty(yyContinueSet);
  1580.   for (yyTerminal = yyFirstTerminal;yyTerminal <= yyLastTerminal;yyTerminal++)
  1581.    {
  1582.     if (yyNext(yyState,yyTerminal) != yyNoState && yyIsContinuation(yyTerminal,yyStack,yyStackSize,yyStackPtr))
  1583.       Include(yyContinueSet,(short)yyTerminal);
  1584.    }
  1585.  }
  1586.  
  1587.  
  1588. /* check whether a given terminal symbol can be accepted (read)
  1589.    in a certain stack configuration (eventually after reduce actions) */
  1590.  
  1591. static bool yyIsContinuation(yySymbolRange yyTerminal, yyStateRange *yyStateStack, unsigned long yyStackSize, short yyStackPtr)
  1592.  {
  1593.   register yyStateRange yState;
  1594.   register yySymbolRange yyNonterminal;
  1595.   yyStateRange *yyStack;
  1596.  
  1597.   MakeArray ((char **)&yyStack,&yyStackSize,sizeof(yyStateRange)); /* pass Stack by value */
  1598.   #ifdef BCOPY
  1599.     bcopy((char *)yyStateStack,(char *)yyStack,(int)sizeof(yyStateRange) * (yyStackPtr+1));
  1600.   #else
  1601.     memcpy((char *)yyStack,(char *)yyStateStack,(int)sizeof(yyStateRange) * (yyStackPtr+1));
  1602.   #endif
  1603.   yState = yyStack[yyStackPtr];
  1604.   for (;;)
  1605.    {
  1606.     yyStack[yyStackPtr] = yState;
  1607.     yState = yyNext(yState, yyTerminal);
  1608.     if (yState == yyNoState)
  1609.      {
  1610.       ReleaseArray((char **)&yyStack,&yyStackSize,sizeof(yyStateRange));
  1611.       return false;
  1612.      }
  1613.     if (yState <= yyLastReadTermState)
  1614.      {/* read or read terminal reduce ? */
  1615.       ReleaseArray((char **)&yyStack,&yyStackSize,sizeof(yyStateRange));
  1616.       return true;
  1617.      }
  1618.     for (;;)
  1619.      {/* reduce */
  1620.       if (yState == yyStopState)
  1621.        {
  1622.         ReleaseArray((char **)&yyStack,&yyStackSize,sizeof(yyStateRange));
  1623.         return true;
  1624.        }
  1625.       else
  1626.        {
  1627.         yyStackPtr -= yyLength[yState - yyFirstReduceState];
  1628.         yyNonterminal = yyLeftHandSide[yState - yyFirstReduceState];
  1629.        }
  1630.       yState = yyNext(yyStack[yyStackPtr],yyNonterminal);
  1631.       if (yyStackPtr >= yyStackSize)
  1632.        {
  1633.         ExtendArray((char **)&yyStack,&yyStackSize,sizeof(yyStateRange));
  1634.        }
  1635.       yyStackPtr++;
  1636.       if (yState < yyFirstFinalState)
  1637.         break; /* read nonterminal ? */
  1638.       yState = yyFinalToProd[yState - yyFirstReadTermState]; /* read nonterminal reduce */
  1639.      }
  1640.    }
  1641.  }
  1642.  
  1643.  
  1644. /* compute a set of terminal symbols that can be used to restart
  1645.    parsing in a given stack configuration. we simulate parsing until
  1646.    end of file using a suffix program synthesized by the function
  1647.    Continuation. All symbols acceptable in the states reached during
  1648.    the simulation can be used to restart parsing. */
  1649.  
  1650. static void yyComputeRestartPoints(yyStateRange *yyStateStack, unsigned long yyStackSize, short yyStackPtr, tSet *yyRestartSet)
  1651.  {
  1652.   register yyStateRange yState;
  1653.   register yySymbolRange yyNonterminal;
  1654.   yyStateRange *yyStack;
  1655.   tSet yyContinueSet;
  1656.  
  1657.   MakeArray ((char **)&yyStack,&yyStackSize,sizeof(yyStateRange)); /* pass Stack by value */
  1658.   #ifdef BCOPY
  1659.     bcopy((char *)yyStateStack,(char *)yyStack,(int)sizeof(yyStateRange) * (yyStackPtr+1));
  1660.   #else
  1661.     memcpy((char *)yyStack,(char *)yyStateStack,(int)sizeof(yyStateRange) * (yyStackPtr+1));
  1662.   #endif
  1663.   MakeSet(&yyContinueSet,(short)yyLastTerminal);
  1664.   AssignEmpty(yyRestartSet);
  1665.   yState = yyStack[yyStackPtr];
  1666.   for (;;)
  1667.    {
  1668.     if (yyStackPtr >= yyStackSize)
  1669.       ExtendArray((char **)&yyStack,&yyStackSize,sizeof(yyStateRange));
  1670.     yyStack[yyStackPtr] = yState;
  1671.     yyComputeContinuation(yyStack,yyStackSize,yyStackPtr,&yyContinueSet);
  1672.     Union(yyRestartSet,&yyContinueSet);
  1673.     yState = yyNext(yState,yyContinuation[yState]);
  1674.     if (yState >= yyFirstFinalState)
  1675.      {/* final state ? */
  1676.       if (yState <= yyLastReadTermState)
  1677.        {/* read terminal reduce ? */
  1678.         yyStackPtr++;
  1679.         yState = yyFinalToProd[yState - yyFirstReadTermState];
  1680.        }
  1681.       for (;;)
  1682.        {/* reduce */
  1683.         if (yState == yyStopState)
  1684.          {
  1685.           ReleaseSet(&yyContinueSet);
  1686.           ReleaseArray((char **)&yyStack,&yyStackSize,sizeof(yyStateRange));
  1687.           return;
  1688.          }
  1689.         else
  1690.          {
  1691.           yyStackPtr -= yyLength[yState - yyFirstReduceState];
  1692.           yyNonterminal = yyLeftHandSide[yState - yyFirstReduceState];
  1693.          }
  1694.         yState = yyNext(yyStack[yyStackPtr],yyNonterminal);
  1695.         yyStackPtr++;
  1696.         if (yState < yyFirstFinalState)
  1697.           break; /* read nonterminal ? */
  1698.         yState = yyFinalToProd[yState - yyFirstReadTermState]; /* read nonterminal reduce */
  1699.        }
  1700.      }
  1701.     else
  1702.      {/* read */
  1703.       yyStackPtr++;
  1704.      }
  1705.    }
  1706.  }
  1707.  
  1708.  
  1709. /* access the parse table:   Next : State x Symbol -> Action */
  1710.  
  1711. static yyStateRange yyNext(yyStateRange yyState,yySymbolRange yySymbol)
  1712.  {
  1713.   register yyTCombType *yyTCombPtr;
  1714.  
  1715.   if (yySymbol <= yyLastTerminal)
  1716.    {
  1717.     for (;;)
  1718.      {
  1719.       yyTCombPtr = yyTBasePtr[yyState] + yySymbol;
  1720.       if (yyTCombPtr->Check != yyState)
  1721.        {
  1722.         if ((yyState = yyDefault[yyState]) == yyNoState)
  1723.           return yyNoState;
  1724.        }
  1725.       else
  1726.         return yyTCombPtr->Next;
  1727.      }
  1728.    }
  1729.   else
  1730.     return *(yyNBasePtr[yyState] + yySymbol);
  1731.  }
  1732.  
  1733.  
  1734. static void BeginPhoneLogParser(void)
  1735.  {
  1736. /* line 31 "t:lalr.tmp" */
  1737. /* line 30 "PhoneLogParser.lalr" */
  1738. /* BEGIN */
  1739.         /* BEGIN */
  1740.  }
  1741.  
  1742.  
  1743. void ClosePhoneLogParser(void)
  1744.  {
  1745.  
  1746.  }
  1747.